
import { 系统 } from "./sys"
import { 库词典, 标识符_, 译文_ } from "../ctsEnumsAndTypes/enumsAndTypes";
import { 结合路径 } from "./utils";

export let 总库: Map<string, 库词典>;

export function 取词典库文件全名(): string {
    let 路径 = 结合路径(系统.取系统临时文件目录(), "cts_扩展");
    let 文件名 = "CTS_翻译词典.utf8";
    return 结合路径(路径, 文件名);
}

export function 创建词典库目录及文件() {

    let 路径 = 结合路径(系统.取系统临时文件目录(), "cts_扩展");
    let 文件名 = "cts_翻译词典.utf8";

    if (!系统.目录存在(路径)) {
        系统.创建目录(路径);
    }
    if (!系统.文件存在(文件名)) {
        系统.写文件(结合路径(路径, 文件名), "");
    }

}

export function 加载词库() {

    function 加载() {
        总库 = new Map();
        try {
            let 文件内容 = 系统.读文件(取词典库文件全名());
            if (!文件内容) {
                创建词典库目录及文件();
                return 总库;
            }
            let 行数据 = 读一行(文件内容);
            while (true) {
                let 数据 = 行数据.next().value;
                if (!数据) {
                    break;
                }
                let 分割组 = 数据.split(":");
                if (总库.has(分割组[0])) {
                    let 存在 = 总库.get(分割组[0]);
                    if (!存在!.译文列表) {
                        存在!.译文列表 = new Map();
                    }
                    let 文字组 = 分割组[1].split(",");
                    for (let v of 文字组) {
                        let 分开系数 = v.split("|");
                        if (!存在!.译文列表.has(分开系数[0])) {
                            存在!.译文列表.set(分开系数[0], +分开系数[1]);
                        }
                    }
                }
                else {
                    let 映射: Map<string, number> = new Map();
                    let 文字组 = 分割组[1].split(",");
                    for (let v of 文字组) {
                        let 分开系数 = v.split("|");
                        if (!映射.has(分开系数[0])) {
                            映射.set(分开系数[0], +分开系数[1]);
                        }
                    }
                    总库.set(分割组[0], { 译文列表: 映射 });
                }
            }
            return 总库;
        } catch (err) {
            return 总库;
        }
    }
    return 总库 || 加载();
}

export function* 读一行(文字: string) {
    if (!文字) {
        return;
    }
    let 分割符 = "\n";
    if (文字.indexOf("\r\n") !== -1) {
        分割符 = "\r\n";
    }
    let 行数据 = 文字.split(分割符);
    for (let v of 行数据) {
        let 值 = v.trim();
        if (值) {
            yield 值;
        }
    }
}

export function 读词典数据(标识符: 标识符_) {
    if (标识符.译文组) {
        return 标识符;
    }
    let 整体返回 = 加载词库().get(标识符.原文.toLowerCase());
    if (整体返回) {
        let 返回结果: 译文_[] = [];
        整体返回.译文列表.forEach((v, k) => {
            let 组合 = { 译文: k, 次数: +v };
            返回结果.push(组合);
        });
        标识符.译文组 = 返回结果.sort(译文组排序);
    }

    if (标识符.组成) {
        for (let v of 标识符.组成) {
            if (!v.译文组) {
                let 库内存在 = 加载词库().get(v.原文.toLowerCase());
                if (库内存在) {
                    let 翻译组成: 译文_[] = [];
                    库内存在.译文列表.forEach((v, k) => {
                        let 组合 = { 译文: k, 次数: +v };
                        翻译组成.push(组合);
                    });
                    v.译文组 = 翻译组成.sort(译文组排序);
                }
            }
        }
    }
    return 标识符;
}

export function 插入词典数据(内容: 标识符_) {
    try {
        if (加载词库().has(内容.原文.toLowerCase())) {
            let 存在 = 加载词库().get(内容.原文.toLowerCase())!;
            let 译文组成 = 内容.译文组!;

            for (let v of 译文组成) {
                if (!存在.译文列表.has(v.译文)) {
                    存在.译文列表.set(v.译文, 1);
                }
                else if (v.增加引用) {
                    v.增加引用 = false;
                    let i = 存在.译文列表.get(v.译文);
                    存在.译文列表.set(v.译文, i! += 5);
                }
            }

        }
        else {
            let 映射: Map<string, number> = new Map();
            let 译文组成 = 内容.译文组!;
            for (let v of 译文组成) {
                映射.set(v.译文, 1);
            }
            加载词库().set(内容.原文.toLowerCase(), { 译文列表: 映射 });
        }

        return true;
    } catch (err) {
        return false;
    }
}

function 译文组排序(a: 译文_, b: 译文_): number {
    if (a.次数 === b.次数) {
        return 0;
    }
    if (a.次数 > b.次数) {
        return 1;
    }
    return -1;
}

export function 删除词典条目(键: string, 值: string) {
    let 总词典 = 加载词库();
    if (总词典.has(键.toLowerCase())) {
        let 存在 = 总词典.get(键.toLowerCase());
        if (存在!.译文列表.size === 1) {
            for (let v of 存在!.译文列表.keys()) {
                if (v === 值) {
                    总词典.delete(键.toLowerCase());
                    return true;
                }
            }
        }
        else {
            for (let v of 存在!.译文列表.keys()) {
                if (v === 值) {
                    存在!.译文列表.delete(值);
                    return true;
                }
            }
        }
    }
    return false;
}
